import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import org.junit.Test;

import java.util.Arrays;

/**
 * 程序只有一个入口：main方法 程序入口
 * 理解：类中只有一个主方法
 *
 * 类中多个类似主方法;单元测试 Junit1.4 {外置jar包}
 *                 jar 别写好的类，直接使用
 *单元测试：专门测试功能模块
 * 单元测试步骤：
 * 1.编写注解    @Test 编写单元测试
 * 2.编写方法    修饰符 方法名(){}
 */


public class 基础语法 {
    /**
     *float 单精度 不常用 4字节 取小数点后六位有效数
     *写法：float 标识符=字面量F/f：
     */
    @Test
    public void basic(){
    float pi=3.1415926535F;
        System.out.println(pi);
        int a=128+256;
        byte b=(byte)a;
        System.out.println(b);
      /*  int _123F=a;
        int 123F=c;
        int if=g;
       */
        String name="贼贼贼";
        int age=18;
        System.out.println(name+age);
        int i=1;
        int j=i++ + i++ + ++i +i++;
        System.out.println(j);
    }
    /**
     * 数组  Array 引用类型          对象，通过new创建
     *数组相当于一堆相同的"数据"集合
     *单元测试：testArray    创建数组方式以及初始化
     */
@Test
   public void testArray(){
    //创建arr数组，长度4
      int[] arr=new int[4];  //动态初始化：指定空间并且按照空间分元素        常用
      int[] arr1={1,2,3};   //静态初始化:直接给定值                       常用
      int arr2[]=new int[4];//动态初始化 指定空间 并且按照空间部分元素            不常用
      int[] arr3=new int[]{1,2,3};//动态初始化：指定空间，并且按照空间分元素      不常用
      //从arr1中静态数组获取 2 元素   数组名{下标}
    System.out.println(arr1[1]); //输出2元素
    //从arr1静态初始化数组获取  长度 数组名 length 从1开始计算
    System.out.println(arr1.length); //输出 3
    //从arr1获取下标为4的值会输出什么  数组下标越界异常 报错
    //System.out.println(arr1[4]);
    //空间长度没有超出范围，数据类型 基础数据类型
    //           int     默认值
    //           float   默认值  0,0
    //           char    默认值  特殊符号
    //           boolean 默认值  false
    //int arr4[]=new int[4];
    //System.out.println(arr4[1]);
    //float[] arr5=new float[4];
    //System.out.println(arr5[1]);
   // char[] arr6=new char[4];
    //System.out.println(arr6[1]);
    //boolean[] arr7=new boolean[4];
   // System.out.println(arr7[1]);
}
/**
 * 数据遍历{三种迭代方式}
 * 1.普通for jdk1.5之前使用
 * 2.增强for jdk1.5之后使用  推荐
 * 3.工具类  推荐
 */
@Test
public void testIterate(){
    int[] arr={1,2,3,4};
   // for (int i=0;i< arr.length;i++){  //获取数组下标
   //     System.out.println(arr[i]);

   //   for(int i:arr){  //直接打印元素值 遍历数据类型
   //       System.out.println(i);


      //工具类 toString 方法 打印所有数组组元素
    System.out.println(Arrays.toString(arr));
}
    /**
     *数组扩容
     * Java数组对象大小是固定的，数组对象不可以扩展的
     * 使用数组扩容方式变通
     * Arrays.copy0f() 方法创建数组剧本
     */
    @Test
    public void testCopy(){
        char[] arr={'唐','山'};   //定义数组，长度固定：2个
        //使用Arrays提供方法创建当前数组的副本
        char[] temp= Arrays.copyOf(arr,4);
        //副本 复制给 不可改变数组
        char[] tarr=temp;
        System.out.println(tarr);//唐 山/u0000/u0000
        tarr[2]='工'; tarr[3]='业';
        System.out.println(tarr);
    }
/**
 * 拓展：数组输出，根据数据类型不同，输出效率不同【看】
 * 数组语法：
 *     数据类型[] 数组名=new 数据类型[]
 *     数据类型：基础数据类型＋引用类型
 *     创建数据根据数据类型：明确是什么类型
 */
@Test
  public void testLook(){
   //字符数组
   char[] china={'中','国'};
    System.out.println(china);//输出中国
    //javaOOP面向对象知识点：数组输出方法提供重载功能，字符数组，优化为字符串
    //常规数组输出效果 Arrays工具类 toString方法：打印数组
    System.out.println( Arrays.toString(china));

    //数值数组
    int[] i={1,2};
    System.out.println(i);  //   “[ 数组” “I类型” “@” “地址值3d82c5f3”
}
/**
 * 数组经典案例
 * int[] arr={3,6,4,1}
 * 数组元素排序：升序，降序
 * 面试题：上述数组按照升序方式排序
 * 解题思路三种方案：选择排序，冒泡排序√，插入排序
 * 冒泡排序：双层for循环使用，比较相邻的元素，将小的值放在前面
 */
    @Test
    public void bubbleSort(){
        int[] arr={3,6,4,1}; //静态数组
        for(int i=0;i<arr.length-1;i++){//外层for：控制比较轮次
            for(int j=0;j<arr.length-1-i;j++){ //内层for：两两比较
               //交换：第一个值>第二个值 成立 交换
                if(arr[j]>arr[j+1]){//第一值；元素arr[j]  第二值：元素arr
                    //交换：第三方数组  交换数组名temp
                 int temp=arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=temp;
             }
          }
        }
        System.out.println(Arrays.toString(arr));
    }

    @Test

    public void sort(){
        int[] arr={3,6,4,1};
        //工具类：提供sort()排序方法
        Arrays.sort(arr); //默认升序
        System.out.println(Arrays.toString(arr));
    }
  }

